import pandas as pd

import numpy as np

import seaborn as sns

import matplotlib.pyplot as plt

import plotly.express as px

from sklearn.preprocessing import PolynomialFeatures

from sklearn.linear_model import LinearRegression as LR

df = pd.read_csv("C:/Ritik Sharma/VIT  2nd SEMESTER/EDA J PROJECT/Electric_Vehicle_Population_Data.csv")

df

df1 = df.drop(columns=['VIN (1-10)', 'City', 'State', 'DOL Vehicle ID', 'Vehicle Location', '2020 Census Tract'])

df1

len(df1.columns)

df1.shape

df1.head()

# Unique values of all the columns in the data set.

​

cols = df1.columns

def Unique_Values():

    for i in np.arange(0,len(cols)):

        print('There are {} nos of unique values in {} column out of {}'.format(df[cols[i]].nunique(), cols[i], len(df)))

Unique_Values()

df1.info()

# to view the statistical values of numerical columns

​

df1.describe().style.background_gradient(cmap='cividis')

df1.isnull().sum()

# to view the missing percentages

​

missing_percentages=df1.isna().sum().sort_values(ascending=False)/len(df1)

missing_percentages

missing_percentages[missing_percentages !=1]

# To plot the missing percentage of the columns in the data set.

​

missing_percentages[missing_percentages != 1].plot(kind = 'barh')

# Visualize the missing data in percentages using basic numerical equation.

​

data_missing = df1.isnull().sum()*100/len(df1)

data_missing

plt.figure(figsize=(20,18))

sns.heatmap(df1.isnull(), yticklabels=False, cmap='viridis')

df1['County'].fillna(df1['County'].mode()[0], inplace=True)

# Use mean of Legislative District column to fill the null values of Legislative District Column.

​

df1['Legislative District'].fillna(df1['Legislative District'].mean(),inplace =True)

# Using the forwardfill and backwardfill method in Pandas, we can fill all the rows with missing values

​

df1['Electric Utility'].fillna('ffill',inplace =True)

df1['Postal Code'].fillna('bfill',inplace =True)

# Assuming 'Electric Range' is the column name

df1 = df1[df1['Electric Range'] != 0]

# Assuming 'Base MSRP' is the column name

df1 = df1[df1['Base MSRP'] != 0]

df1.isnull().sum()

df1['Electric Range'].unique()

df1['Model'].unique()

df1['Legislative District'].unique()

df1['Make'].unique()

df1["Electric Range"].replace(0, pd.NA, inplace=True)

df1["Legislative District"].replace(0, pd.NA, inplace=True)

print("\nCleaned Dataset:")

df1.head()

import pandas as pd

​

# Assuming df1 is the cleaned dataset

​

# Label Encoding for categorical variables with ordinality

from sklearn.preprocessing import LabelEncoder

​

label_encoder = LabelEncoder()

# Example: Encoding 'Electric Vehicle Type' column

df1['Clean Alternative Fuel Vehicle (CAFV) Eligibility'] = label_encoder.fit_transform(df1['Clean Alternative Fuel Vehicle (CAFV) Eligibility'])

​

# Viewing the modified dataset

df1.head()

import pandas as pd

​

​

# 1. Create a new feature for the age of the vehicle

current_year = 2024  # Assuming the current year

df1['Vehicle Age'] = current_year - df1['Model Year']

​

​

# Viewing the modified dataset

df1.head()

# 2. Create a binary feature indicating if the vehicle is a luxury brand

luxury_brands = ['BMW', 'Mercedes-Benz', 'Audi', 'Lexus', 'Porsche', 'KIA', 'VOLVO', 'TESLA', 'CHRYSLER', 'Bentley']

df1['Is Luxury Brand'] = df1['Make'].isin(luxury_brands).astype(int)

​

# Viewing the modified dataset

df1.head()

df1

# Save the DataFrame to a CSV file

df1.to_csv('clean_dataset.csv', index=False)

​

import os

​

# Get the current working directory (where your Python script is located)

current_directory = os.getcwd()

​

print("Current Directory:", current_directory)

​

df2=pd.read_csv("C:/Ritik Sharma/VIT  2nd SEMESTER/EDA J PROJECT/clean_dataset.csv")

# Visual Inspection - Histograms

df2.hist(figsize=(12, 8))

plt.tight_layout()

plt.show()

​

# Visual Inspection - Boxplots

df2.boxplot(figsize=(12, 8))

plt.xticks(rotation=30)

plt.show()

import pandas as pd

import dask.dataframe as dd

import numpy as np

​

# Define data types for columns

dtypes = {'Legislative District': 'float64', 'Postal Code': 'object'}

​

# Load the dataset using Dask and specify the data types

ddf = dd.read_csv("C:/Ritik Sharma/VIT  2nd SEMESTER/EDA J PROJECT/clean_dataset.csv", dtype=dtypes)

​

# Select only numeric columns

numeric_cols = ddf.select_dtypes(include=np.number)

​

# Calculate z-scores

z_scores = (numeric_cols - numeric_cols.mean()) / numeric_cols.std()

​

# Identify outliers based on z-scores

outliers_zscore = ddf[((z_scores > 3) | (z_scores < -3)).any(axis=1)]

​

# Compute IQR

Q1 = numeric_cols.quantile(0.25)

Q3 = numeric_cols.quantile(0.75)

IQR = Q3 - Q1

​

# Identify outliers based on IQR

outliers_iqr = ddf[((numeric_cols < (Q1 - 1.5 * IQR)) | (numeric_cols > (Q3 + 1.5 * IQR))).any(axis=1)]

​

# Convert Dask DataFrame to Pandas DataFrame for printing

outliers_zscore_pd = outliers_zscore.compute()

outliers_iqr_pd = outliers_iqr.compute()

​

print("Potential Outliers based on Z-scores:")

print(outliers_zscore_pd)

print("\nPotential Outliers based on IQR:")

print(outliers_iqr_pd)

# Calculate the first quartile (Q1)

Q1 = df2['Base MSRP'].quantile(0.25)

​

# Calculate the third quartile (Q3)

Q3 = df2['Base MSRP'].quantile(0.75)

​

# Calculate the interquartile range (IQR)

IQR = Q3 - Q1

​

# Define the lower and upper bounds for outliers

lower_bound = Q1 - 4.5 * IQR

upper_bound = Q3 + 4.5 * IQR

​

print("Lower bound for outliers:", lower_bound)

print("Upper bound for outliers:", upper_bound)

​

# Merge outlier detection results

merged_outliers = pd.concat([outliers_zscore_pd, outliers_iqr_pd])

​

# Remove duplicate rows if any

merged_outliers = merged_outliers.drop_duplicates()

​

# Optionally, add a column indicating the method used for outlier detection

merged_outliers['Outlier Detection Method'] = np.where(merged_outliers.index.isin(outliers_zscore_pd.index), 'Z-score', 'IQR')

​

# Reset index

merged_outliers.reset_index(drop=True, inplace=True)

​

# Print the merged outlier detection results

print("Merged Outliers:")

print(merged_outliers)

import matplotlib.pyplot as plt

import seaborn as sns

​

# Ensure df is loaded properly with your dataset

​

# Features more likely to be useful for predicting future sales of cars

features_for_prediction = ['Model Year', 'Clean Alternative Fuel Vehicle (CAFV) Eligibility', 

                          'Electric Range', 'Base MSRP']

​

# Outlier analysis (box plot) for numerical features

for column in features_for_prediction:

    if df[column].dtype != 'object':

        plt.figure(figsize=(8, 6))

        sns.boxplot(x=df[column])

        plt.title(f'Boxplot of {column}')

        plt.xlabel(column)

        plt.ylabel('Values')

        plt.show()

import matplotlib.pyplot as plt

import seaborn as sns

​

# Ensure df2 is loaded properly with your dataset

​

# Features more likely to be useful for predicting future sales of cars

features_for_prediction = ['Model Year', 

                          'Electric Range', 'Base MSRP']

​

for column in features_for_prediction:

    if ddf[column].dtype != 'object':

        plt.figure(figsize=(8, 6))

        sns.boxplot(x=column, data=ddf.compute())  # Using data=ddf.compute() to convert Dask DataFrame to Pandas for plotting

        plt.title(f'Boxplot of {column}')

        plt.xlabel(column)

        plt.ylabel('Values')

        plt.show()

from sklearn.neighbors import NearestNeighbors

from scipy.cluster.hierarchy import dendrogram, linkage

​

# Step 1: KNN-based outlier detection

def knn_outlier_detection(data, k=100):

    numeric_data = data.select_dtypes(include=np.number)  # Select only numeric columns

    nbrs = NearestNeighbors(n_neighbors=k).fit(numeric_data)

    distances, _ = nbrs.kneighbors(numeric_data)

    return np.mean(distances, axis=1)

​

# Compute outlier scores using KNN

outlier_scores = knn_outlier_detection(df2)

outlier_scores

# Step 2: Dendrogram-based outlier detection

def dendrogram_outlier_detection(data):

    numeric_data = data.select_dtypes(include=np.number)  # Select only numeric columns

    Z = linkage(numeric_data, method='ward')

    plt.figure(figsize=(20, 8))

    dendrogram(Z)

    plt.title('Hierarchical Clustering Dendrogram')

    plt.xlabel('Sample Index')

    plt.ylabel('Distance')

    plt.show()

​

# Perform dendrogram-based outlier detection

dendrogram_outlier_detection(df2)

​

# You can further analyze the dendrogram to identify potential outliers visually.

​

# Step 1: Define KNN-based outlier detection function

def knn_outlier_detection(data, column, k=5):

    column_data = data[column].values.reshape(-1, 1)  # Reshape to 2D array

    nbrs = NearestNeighbors(n_neighbors=k).fit(column_data)

    distances, _ = nbrs.kneighbors(column_data)

    return np.mean(distances, axis=1)

​

# Step 2: Define dendrogram-based outlier detection function

def dendrogram_outlier_detection(data, column):

    column_data = data[column].values.reshape(-1, 1)  # Reshape to 2D array

    Z = linkage(column_data, method='ward')

    plt.figure(figsize=(10, 5))

    dendrogram(Z)

    plt.title(f'Hierarchical Clustering Dendrogram - {column}')

    plt.xlabel('Sample Index')

    plt.ylabel('Distance')

    plt.show()

​

# Step 3: Perform outlier analysis and plot for each column

columns_of_interest = ['Model Year', 'Electric Range', 'Base MSRP']

for column in columns_of_interest:

    # KNN-based outlier detection

    outlier_scores = knn_outlier_detection(df2, column)

    # Dendrogram-based outlier detection

    dendrogram_outlier_detection(df2, column)

    # Optionally, plot the KNN-based outlier scores

    plt.figure(figsize=(8, 6))

    plt.plot(range(len(outlier_scores)), outlier_scores, marker='o', linestyle='-', color='b')

    plt.title(f'KNN Outlier Detection - {column}')

    plt.xlabel('Sample Index')

    plt.ylabel('Outlier Score')

    plt.grid(True)

    plt.show()

# Step 1: Define KNN-based outlier detection function

def knn_outlier_detection(data, column, k=5):

    nbrs = NearestNeighbors(n_neighbors=k)

    distances = nbrs.fit(data[[column]]).kneighbors()[0]

    return np.mean(distances, axis=1)

​

# Step 2: Define dendrogram-based outlier detection function

def dendrogram_outlier_detection(data, column):

    Z = linkage(data[[column]], method='ward')

    plt.figure(figsize=(10, 5))

    dendrogram(Z)

    plt.title(f'Hierarchical Clustering Dendrogram - {column}')

    plt.xlabel('Sample Index')

    plt.ylabel('Distance')

    plt.show()

​

# Step 3: Perform outlier analysis and plot for each column

columns_of_interest = ['Model Year', 'Electric Range', 'Base MSRP']

for column in columns_of_interest:

    # KNN-based outlier detection

    outlier_scores = knn_outlier_detection(ddf, column)

    # Dendrogram-based outlier detection

    dendrogram_outlier_detection(ddf, column)

    # Optionally, plot the KNN-based outlier scores

    plt.figure(figsize=(8, 6))

    plt.plot(range(len(outlier_scores)), outlier_scores, marker='o', linestyle='-', color='b')

    plt.title(f'KNN Outlier Detection - {column}')

    plt.xlabel('Sample Index')

    plt.ylabel('Outlier Score')

    plt.grid(True)

    plt.show()

# Distribution of Electric Vehicles Types.

​

ev_types = df2["Electric Vehicle Type"].value_counts().reset_index()

ev_types.columns = (["Electric Vehicle Type", "Number Of Vehicles"])

ev_types

figure, axes = plt.subplots(1, 2, figsize=(14, 6))

​

figure.suptitle('Distribution Of Electric Vehicle Types', fontweight='bold', fontsize=14)

​

barplot = sns.barplot(ev_types, x="Electric Vehicle Type", y="Number Of Vehicles", ax=axes[0], palette="copper")

axes[0].set_xlabel('Electric Vehicle Types', fontweight='bold', fontsize=11)

axes[0].set_ylabel('Number Of Vehicles', fontweight='bold', fontsize=11)

axes[0].set_xticklabels(barplot.get_xticklabels(), fontsize=9)

​

for p in barplot.patches:

    barplot.annotate(f"{p.get_height()}", (p.get_x() + p.get_width() / 2, p.get_height()), va="bottom", ha="center", fontsize=10)

​

sizes1 = ev_types["Number Of Vehicles"]

labels1 = ev_types["Electric Vehicle Type"]

explode1 = [.02, .02]

​

axes[1].pie(sizes1, labels=labels1, autopct='%0.2f%%', shadow=True, explode=explode1, startangle=130)

​

plt.show()

# Count of Cars by Make.

​

plt.figure(figsize=(12,6))

sns.countplot(data=df,x='Make')

plt.xticks(rotation=90)

plt.xlabel('Make')

plt.ylabel('Count')

plt.show()

import matplotlib.pyplot as plt

import seaborn as sns

​

# List of features

features = ['Make', 'Model', 'Electric Vehicle Type', 

            'Clean Alternative Fuel Vehicle (CAFV) Eligibility', 

            'Electric Range', 'Base MSRP', 

            'Legislative District', 'Electric Utility', 

            'Vehicle Age', 'Is Luxury Brand']

​

for feature in features:

    # Histogram

    plt.figure(figsize=(20, 6))

    plt.hist(df2[feature], bins=20, edgecolor='black')

    plt.xlabel(feature)

    plt.ylabel('Frequency')

    plt.title(f'Distribution of {feature}')

    plt.show()

    # Bar Graph

    if df2[feature].dtype == 'object':

        plt.figure(figsize=(12, 6))

        sns.countplot(data=df2, x=feature)

        plt.xticks(rotation=45)

        plt.xlabel(feature)

        plt.ylabel('Count')

        plt.title(f'Count of {feature}')

        plt.show()

    # Pie Chart

    if df2[feature].dtype == 'object':

        plt.figure(figsize=(8,24))

        df2[feature].value_counts().plot(kind='pie', autopct='%1.1f%%')

        plt.title(f'Distribution of {feature}')

        plt.ylabel('')

        plt.show()

    # Frequency Polygon

    plt.figure(figsize=(24, 6))

    sns.histplot(df2[feature], kde=True, color='skyblue')

    plt.xlabel(feature)

    plt.ylabel('Frequency')

    plt.title(f'Frequency Polygon of {feature}')

    plt.show()

    # Scatter Plot

    if df2[feature].dtype != 'object':

        plt.figure(figsize=(8, 6))

        sns.scatterplot(data=df2, x=feature, y='Base MSRP')

        plt.xlabel(feature)

        plt.ylabel('Base MSRP')

        plt.title(f'Scatter Plot of {feature} vs Base MSRP')

        plt.show()

    # Heatmap

    if df2[feature].dtype != 'object':

        plt.figure(figsize=(10, 8))

        sns.heatmap(data=df2.corr(), annot=True, cmap='coolwarm')

        plt.title('Correlation Heatmap')

        plt.show()

​

import matplotlib.pyplot as plt

import seaborn as sns

​

# List of features

features = ['Make', 'Model', 'Electric Vehicle Type', 

            'Clean Alternative Fuel Vehicle (CAFV) Eligibility', 

            'Electric Range', 'Base MSRP', 

            'Legislative District', 'Electric Utility', 

            'Vehicle Age', 'Is Luxury Brand']

​

# Calculate the number of rows and columns for the subplots

num_features = len(features)

num_cols = 2

num_rows = (num_features - 1) // num_cols + 1

​

# Create subplots

fig, axes = plt.subplots(num_rows, num_cols, figsize=(35, 10*num_rows))

​

# Flatten the axes array to iterate over the subplots

axes = axes.flatten()

​

for i, feature in enumerate(features):

    # Histogram

    axes[i].hist(df2[feature], bins=20, edgecolor='black')

    axes[i].set_xlabel(feature)

    axes[i].set_ylabel('Frequency')

    axes[i].set_title(f'Distribution of {feature}')

    axes[i].grid(True)

​

# Adjust layout

plt.tight_layout()

plt.show()

import matplotlib.pyplot as plt

import seaborn as sns

​

# List of features

features = ['Make', 'Model', 'Electric Vehicle Type', 

            'Clean Alternative Fuel Vehicle (CAFV) Eligibility', 

            'Electric Range', 'Base MSRP', 

            'Legislative District', 'Electric Utility', 

            'Vehicle Age', 'Is Luxury Brand']

​

# Calculate the number of rows and columns for the subplots

num_features = len(features)

num_cols = 2

num_rows = (num_features - 1) // num_cols + 1

​

# Create subplots

fig, axes = plt.subplots(num_rows, num_cols, figsize=(35, 10*num_rows))

​

# Flatten the axes array to iterate over the subplots

axes = axes.flatten()

​

for i, feature in enumerate(features):

    # Frequency Polygon

    sns.histplot(df2[feature], kde=True, color='skyblue', ax=axes[i])

    axes[i].set_xlabel(feature)

    axes[i].set_ylabel('Frequency')

    axes[i].set_title(f'Frequency Polygon of {feature}')

    axes[i].grid(True)

​

​

# Adjust layout

plt.tight_layout()

plt.show()

import dash

from dash import dcc, html

from dash.dependencies import Input, Output

import plotly.express as px

import pandas as pd

import dask.dataframe as dd

import seaborn as sns

import matplotlib.pyplot as plt

​

# Load the dataset using Dask and specify the data types

dtypes = {'County': 'object', 

          'Postal Code': 'object', 

          'Model Year': 'float64', 

          'Make': 'object', 

          'Model': 'object', 

          'Electric Vehicle Type': 'object',

          'Clean Alternative Fuel Vehicle (CAFV) Eligibility': 'float64',

          'Electric Range': 'float64',

          'Base MSRP': 'float64',

          'Legislative District': 'float64',

          'Electric Utility': 'object',

          'Vehicle Age': 'float64',

          'Is Luxury Brand': 'float64'}

​

ddf = dd.read_csv("C:/Ritik Sharma/VIT  2nd SEMESTER/EDA J PROJECT/clean_dataset.csv", dtype=dtypes)

​

# Define the Dash app

app = dash.Dash(__name__)

​

# Define the layout of the dashboard

app.layout = html.Div([

    html.H1("Interactive Electric Vehicle Dashboard"),

    # Add dropdowns for selecting features

    html.Div([

        dcc.Dropdown(

            id='x-dropdown',

            options=[

                {'label': col, 'value': col} for col in ddf.columns

            ],

            value='Electric Range',

            clearable=False,

            style={'width': '48%', 'display': 'inline-block'}

        ),

        dcc.Dropdown(

            id='y-dropdown',

            options=[

                {'label': col, 'value': col} for col in ddf.columns

            ],

            value='Base MSRP',

            clearable=False,

            style={'width': '48%', 'float': 'right', 'display': 'inline-block'}

        )

    ]),

    # Add scatter plot

    dcc.Graph(id='scatter-plot'),

    # Add histogram

    dcc.Graph(id='histogram'),

    # Add pie chart

    dcc.Graph(id='pie-chart'),

​

    # Add bar graph

    dcc.Graph(id='bar-graph'),

​

    # Add box plot

    dcc.Graph(id='box-plot'),

​

    # Add line plot

    dcc.Graph(id='line-plot'),

​

    # Add area plot

    dcc.Graph(id='area-plot'),

​

    # Add heatmap

    dcc.Graph(id='heatmap')

])

​

# Define callback to update scatter plot

@app.callback(

    Output('scatter-plot', 'figure'),

    [Input('x-dropdown', 'value'),

     Input('y-dropdown', 'value')]

)

def update_scatter_plot(x_feature, y_feature):

    fig = px.scatter(ddf.compute(), x=x_feature, y=y_feature, color='Electric Vehicle Type', 

                     hover_name='Make', hover_data=['Model Year', 'Electric Range', 'Base MSRP'],

                     title=f'Scatter Plot: {y_feature} vs {x_feature}',

                     labels={x_feature: x_feature, y_feature: y_feature})

    return fig

​

# Define callback to update histogram

@app.callback(

    Output('histogram', 'figure'),

    [Input('x-dropdown', 'value')]

)

def update_histogram(x_feature):

    fig = px.histogram(ddf.compute(), x=x_feature, nbins=20, title=f'Histogram: {x_feature}',

                       labels={x_feature: x_feature, 'count': 'Frequency'})

    return fig

​

# Define callback to update pie chart

@app.callback(

    Output('pie-chart', 'figure'),

    [Input('y-dropdown', 'value')]

)

def update_pie_chart(y_feature):

    fig = px.pie(ddf.compute(), names=y_feature, title=f'Pie Chart: Distribution of {y_feature}',

                 hole=0.3)

    return fig

​

# Define callback to update bar graph

@app.callback(

    Output('bar-graph', 'figure'),

    [Input('x-dropdown', 'value')]

)

def update_bar_graph(x_feature):

    bar_data = ddf[x_feature].value_counts().compute()

    fig = px.bar(x=bar_data.index, y=bar_data.values, title=f'Bar Graph: {x_feature}', 

                 labels={x_feature: x_feature, 'y': 'Count'})

    return fig

​

​

​

# Define callback to update box plot

@app.callback(

    Output('box-plot', 'figure'),

    [Input('x-dropdown', 'value')]

)

def update_box_plot(x_feature):

    fig = px.box(ddf.compute(), x=x_feature, title=f'Box Plot: {x_feature}', 

                 labels={x_feature: x_feature, 'y': 'Value'})

    return fig

​

# Define callback to update line plot

@app.callback(

    Output('line-plot', 'figure'),

    [Input('x-dropdown', 'value'),

     Input('y-dropdown', 'value')]

)

def update_line_plot(x_feature, y_feature):

    fig = px.line(ddf.compute(), x=x_feature, y=y_feature, title=f'Line Plot: {y_feature} vs {x_feature}', 

                  labels={x_feature: x_feature, y_feature: y_feature})

    return fig

​

# Define callback to update area plot

@app.callback(

    Output('area-plot', 'figure'),

    [Input('x-dropdown', 'value'),

     Input('y-dropdown', 'value')]

)

def update_area_plot(x_feature, y_feature):

    fig = px.area(ddf.compute(), x=x_feature, y=y_feature, title=f'Area Plot: {y_feature} vs {x_feature}', 

                  labels={x_feature: x_feature, y_feature: y_feature})

    return fig

​

# Define callback to update heatmap

@app.callback(

    Output('heatmap', 'figure'),

    [Input('x-dropdown', 'value'),

     Input('y-dropdown', 'value')]

)

def update_heatmap(x_feature, y_feature):

    fig = px.imshow(ddf.compute().pivot_table(index=x_feature, columns=y_feature), 

                    labels={'x': x_feature, 'y': y_feature})

    return fig

​

# Run the Dash app

if __name__ == '__main__':

    app.run_server(debug=True)

​

# Dimensionality Reduction.

import pandas as pd

from sklearn.decomposition import PCA

from sklearn.preprocessing import StandardScaler

​

# Assuming df1 contains your dataset with numeric features

​

# Selecting numeric features for PCA

numeric_features = ddf.select_dtypes(include=['int64', 'float64']).columns

​

# Standardize the data

scaler = StandardScaler()

scaled_data = scaler.fit_transform(df1[numeric_features])

​

# Applying PCA

pca = PCA(n_components=4)  # Specify the number of components you want to retain

pca_result = pca.fit_transform(scaled_data)

​

# Creating a DataFrame to visualize the results

pca_df = pd.DataFrame(data=pca_result, columns=['PCA1', 'PCA2', 'PCA3', 'PCA4'])

print(pca_df.head())  # Display the transformed data

pca_df

# Plotting the PCA results

plt.figure(figsize=(10, 6))

sns.scatterplot(x='PCA1', y='PCA2', data=pca_df)

plt.title('PCA Dimensionality Reduction')

plt.xlabel('Principal Component 1')

plt.ylabel('Principal Component 2')

plt.show()

import seaborn as sns

​

# Plotting pairplot for all PCA components

sns.pairplot(pca_df)

plt.suptitle('Pairplot of PCA Components', y=1.02)

plt.show()